home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / mint / network / lattice / dulib.lzh / DU_LIB / PROC_MSG.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-10  |  10.9 KB  |  415 lines
  1. /* 
  2.   DU_LIB v2 
  3.   Gem Window Management & Dialog Library For Lattice C 
  4.   ©1994,95, by Craig Graham. 
  5.  
  6.   Based on the DU_LIBv1 Library for HiSoft Basic. 
  7. */
  8.  
  9. /* 
  10.    GEM AES message handler 
  11. */
  12.  
  13. #include "dulib.h"
  14.  
  15. event process_message(short mb[]) 
  16. { 
  17.     short m,arrow_m,x,y,w,h; 
  18.     short e_wind; 
  19.     OBJECT *a_l; 
  20.     short sx,sy,sw,sh; 
  21.     short a,b; 
  22.     CallBack custom_handler; 
  23.     window_widget_response widget_callbacks;
  24.     CallBack widget_handler;
  25.     event ret_v;
  26.     Wtype t;
  27.  
  28.     ret_v=0; 
  29.     a_l=0;
  30.  
  31.      e_wind=mb[3];    /*Window for which the message arrived*/ 
  32.  
  33.     m=mb[0];        /*Message type*/ 
  34.  
  35.     if (!xacc_message(mb))
  36.     {
  37.         if (m==MN_SELECTED)        /*Event was a menu*/ 
  38.         { 
  39.             rsrc_gaddr(0,menu,&a_l); 
  40.             custom_handler=Get_object_callback(menu, mb[4]);    /*Check for a custom object handler*/ 
  41.             if (!custom_handler) 
  42.             { 
  43.                 ret_v=Get_object_event(menu,mb[4]);    /*Return menu item selected*/ 
  44.                 menu_tnormal(a_l,e_wind,1); 
  45.             }else{
  46.                 this_dialog=menu; this_ob=mb[4];
  47.                 (*custom_handler)();                   /*Call a custom handler for that selection*/ 
  48.                 menu_tnormal(a_l,e_wind,1); 
  49.             }
  50.         } else { 
  51.             if (windows[e_wind].window_type==wt_null) return ret_v;
  52.             
  53.             this_dialog=windows[e_wind].the_dialog;
  54.             cr_wind_handle=e_wind;
  55.             widget_callbacks=dialog_details[windows[e_wind].the_dialog].wind_widgets;
  56.  
  57.             switch(m)                                /*Common messages for all window types*/
  58.             {
  59.                                                     /*Xacc2 support*/
  60.                 case ACC_TEXT:                        /*Recieve Text*/
  61.                     if (XaccTextHandler)
  62.                     {
  63.                         if ((*XaccTextHandler)())
  64.                         {
  65.                             xacc_ack( mb[1], TRUE );
  66.                         }else{
  67.                             xacc_ack( mb[1], FALSE );
  68.                         }
  69.                     }else{
  70.                         xacc_ack( mb[1], FALSE );
  71.                     }
  72.                     break;
  73.                 case WM_CLOSED:
  74.                     widget_handler=widget_callbacks.close_widget;
  75.                     if (widget_handler)
  76.                     {
  77.                         (*widget_handler)();
  78.                     }else{
  79.                         close_dialog_window(e_wind);
  80.                     }
  81.                     break;
  82.                 case WM_TOPPED:
  83.                     wind_get(e_wind,WF_TOP,&a,0,0,0);
  84.                     if (a==e_wind)
  85.                     {
  86.                         wind_set(e_wind,WF_BOTTOM,0,0,0,0); 
  87.                     } else { 
  88.                         wind_set(e_wind,WF_TOP,0,0,0,0); 
  89.                     } 
  90.                     ret_v=3;
  91.                     break; 
  92.                 case WM_BOTTOMED: 
  93.                     wind_set(e_wind,WF_BOTTOM,0,0,0,0); 
  94.                     break; 
  95.                 case WM_UNTOPPED: 
  96.                     break; 
  97.                 case WM_REDRAW: 
  98.                     udx=mb[4]; udy=mb[5]; 
  99.                     udw=mb[6]; udh=mb[7]; 
  100.                     redraw_window(e_wind); 
  101.                     break;
  102.                 case WM_CUSTOM_REDRAW: 
  103.                     udx=mb[4]; udy=mb[5]; 
  104.                     udw=mb[6]; udh=mb[7]; 
  105.                     custom_redraw_window(e_wind); 
  106.                     break;
  107.                 case WM_HSLID:
  108.                     wind_set(e_wind,WF_HSLIDE,mb[4],0,0,0);
  109.                     widget_handler=widget_callbacks.h_slide;
  110.                     if (widget_handler)
  111.                     {
  112.                         (*widget_handler)();
  113.                     }else{
  114.                         if (windows[e_wind].redraw_mode==wrm_window)
  115.                         {
  116.                             if (windows[e_wind].window_type==wt_drawing)
  117.                             {
  118.                                 custom_update_window(e_wind);
  119.                             }else{
  120.                                 update_window(e_wind);
  121.                             }
  122.                         }
  123.                     }
  124.                     break;
  125.                 case WM_VSLID:
  126.                     wind_set(e_wind,WF_VSLIDE,mb[4],0,0,0);
  127.                     widget_handler=widget_callbacks.v_slide;
  128.                     if (widget_handler)
  129.                     {
  130.                         (*widget_handler)();
  131.                     }else{
  132.                         if (windows[e_wind].redraw_mode==wrm_window)
  133.                         {
  134.                             if (windows[e_wind].window_type==wt_drawing)
  135.                             {
  136.                                 custom_update_window(e_wind);
  137.                             }else{
  138.                                 update_window(e_wind);
  139.                             }
  140.                         }
  141.                     }
  142.                     break;
  143.                 case WM_ICONIFY:
  144.                     widget_handler=widget_callbacks.iconify_widget;
  145.                     if (widget_handler)
  146.                     {
  147.                         (*widget_handler)();
  148.                     }else{
  149.                         wind_get(e_wind,WF_CURRXYWH,&sx,&sy,&sw,&sh); 
  150.                         wind_set(e_wind,WF_ICONIFY,0,0,0,0);
  151.                         wind_set(e_wind,WF_CURRXYWH,mb[4],mb[5],mb[6],mb[7]); 
  152.                     }
  153.                     break;
  154.                 case WM_ARROWED:
  155.                     arrow_m=mb[4];
  156.                     widget_handler=widget_callbacks.arrows[arrow_m];
  157.                     if (widget_handler)
  158.                     {
  159.                         (*widget_handler)();
  160.                     }else{
  161.                         arrow_m|=128;
  162.                         switch(arrow_m)
  163.                         {
  164.                             case WIDGET_ARROW_UPPAGE:
  165.                                 wind_get(e_wind,WF_VSLIDE,&a,0,0,0);
  166.                                 a-=100;
  167.                                 if (a<0) a=0;
  168.                                 wind_set(e_wind,WF_VSLIDE,a,0,0,0);
  169.                                 break;
  170.                             case WIDGET_ARROW_DNPAGE:
  171.                                 wind_get(e_wind,WF_VSLIDE,&a,0,0,0);
  172.                                 a+=100;
  173.                                 if (a>1000) a=1000;
  174.                                 wind_set(e_wind,WF_VSLIDE,a,0,0,0);
  175.                                 break;
  176.                             case WIDGET_ARROW_UPLINE:
  177.                                 wind_get(e_wind,WF_VSLIDE,&a,0,0,0);
  178.                                 a-=5;
  179.                                 if (a<0) a=0;
  180.                                 wind_set(e_wind,WF_VSLIDE,a,0,0,0);
  181.                                 break;
  182.                             case WIDGET_ARROW_DNLINE:
  183.                                 wind_get(e_wind,WF_VSLIDE,&a,0,0,0);
  184.                                 a+=5;
  185.                                 if (a>1000) a=1000;
  186.                                 wind_set(e_wind,WF_VSLIDE,a,0,0,0);
  187.                                 break;
  188.                             case WIDGET_ARROW_LFPAGE:
  189.                                 wind_get(e_wind,WF_HSLIDE,&a,0,0,0);
  190.                                 a-=100;
  191.                                 if (a<0) a=0;
  192.                                 wind_set(e_wind,WF_HSLIDE,a,0,0,0);
  193.                                 break;
  194.                             case WIDGET_ARROW_RTPAGE:
  195.                                 wind_get(e_wind,WF_HSLIDE,&a,0,0,0);
  196.                                 a+=100;
  197.                                 if (a>1000) a=1000;
  198.                                 wind_set(e_wind,WF_HSLIDE,a,0,0,0);
  199.                                 break;
  200.                             case WIDGET_ARROW_LFLINE:
  201.                                 wind_get(e_wind,WF_HSLIDE,&a,0,0,0);
  202.                                 a-=5;
  203.                                 if (a<0) a=0;
  204.                                 wind_set(e_wind,WF_HSLIDE,a,0,0,0);
  205.                                 break;
  206.                             case WIDGET_ARROW_RTLINE:
  207.                                 wind_get(e_wind,WF_HSLIDE,&a,0,0,0);
  208.                                 a+=5;
  209.                                 if (a>1000) a=1000;
  210.                                 wind_set(e_wind,WF_HSLIDE,a,0,0,0);
  211.                                 break;
  212.                         }
  213.                         if (windows[e_wind].window_type==wt_drawing)
  214.                         {
  215.                             custom_update_window(e_wind);
  216.                         }else{
  217.                             update_window(e_wind);
  218.                         }
  219.                     }
  220.                     break;
  221.             }
  222.         
  223.             t=windows[e_wind].window_type;            /* Type of window we are looking at */ 
  224.             switch(t)
  225.             {
  226.                 case wt_dialog:
  227.                 case wt_dialog_side_bar:
  228.                 case wt_dialog_bottom_bar:
  229.                     switch(m)
  230.                     {
  231.                         case WM_FULLED:                        /*With Dialog Windows, make them Roll-Ups*/ 
  232.                             widget_handler=widget_callbacks.full_widget;
  233.                             if (widget_handler)
  234.                             {
  235.                                 (*widget_handler)();
  236.                             }else{
  237.                                 wind_get(e_wind,WF_WORKXYWH,&sx,&sy,&sw,&sh); 
  238.                                 if (sh) 
  239.                                 {
  240.                                     sh=0;
  241.                                 } else {
  242.                                      rsrc_gaddr(0,windows[e_wind].the_dialog,&a_l); 
  243.                                     form_center(a_l,&a,&b,&sw,&sh);
  244.                                 }
  245.                                 switch(t)
  246.                                 {
  247.                                     case wt_dialog:
  248.                                         wind_calc(WC_BORDER,NAME+CLOSER+FULLER+MOVER+SMALLER,sx,sy,sw,sh,&sx,&sy,&sw,&sh);
  249.                                         break;
  250.                                     case wt_dialog_side_bar:
  251.                                         wind_calc(WC_BORDER,NAME+CLOSER+FULLER+MOVER+UPARROW+DNARROW+VSLIDE+SMALLER,sx,sy,sw,sh,&sx,&sy,&sw,&sh);
  252.                                         break;
  253.                                     case wt_dialog_bottom_bar:
  254.                                         wind_calc(WC_BORDER,NAME+CLOSER+FULLER+MOVER+LFARROW+RTARROW+HSLIDE+SMALLER,sx,sy,sw,sh,&sx,&sy,&sw,&sh);
  255.                                         break;
  256.                                  }
  257.                                  wind_set(e_wind,WF_CURRXYWH,sx,sy,sw,sh);
  258.                              }
  259.                             break;
  260.                         case WM_MOVED: 
  261.                             if (mb[4]<0) { mb[4]=0; } 
  262.                             wind_set(e_wind,WF_CURRXYWH,mb[4],mb[5],mb[6],mb[7]); 
  263.                             rsrc_gaddr(0,windows[e_wind].the_dialog,&a_l); 
  264.                             wind_get(e_wind,WF_WORKXYWH,&x,&y,&w,&h); 
  265.                             if (h!=0)
  266.                             { 
  267.                                 a_l->ob_x=x; 
  268.                                 a_l->ob_y=y; 
  269.                             } 
  270.                             break; 
  271.                         case WM_UNICONIFY:
  272.                             wind_set(e_wind,WF_UNICONIFY,0,0,0,0);
  273.                              rsrc_gaddr(0,windows[e_wind].the_dialog,&a_l);
  274.                             form_center(a_l,&sx,&sy,&sw,&sh);
  275.                             wind_calc(0,15,sx,sy,sw,sh,&sx,&sy,&sw,&sh); 
  276.                              wind_set(e_wind,WF_CURRXYWH,sx,sy,sw,sh);
  277.                             break;
  278.                     }
  279.                     break;
  280.                 case wt_drawing:
  281.                     switch(m)
  282.                     {
  283.                         case WM_FULLED:                        /*With drawing (ie. work area/widget bar) Windows, make them full/shrink */ 
  284.                             widget_handler=widget_callbacks.full_widget;
  285.                             if (widget_handler)
  286.                             {
  287.                                 (*widget_handler)();
  288.                             }else{
  289.                                 wind_get(e_wind,WF_CURRXYWH,&sx,&sy,&sw,&sh); 
  290.                                 wind_get(e_wind,WF_FULLXYWH,&x,&y,&w,&h); 
  291.                                  if ((((sx!=x)||(sy!=y))||(sw!=w))||(sh!=h))
  292.                                  {
  293.                                      wind_set(e_wind,WF_CURRXYWH,x,y,w,h);
  294.                                  }else{
  295.                                     wind_get(e_wind,WF_PREVXYWH,&x,&y,&w,&h); 
  296.                                      wind_set(e_wind,WF_CURRXYWH,x,y,w,h);
  297.                                  }
  298.                                  rsrc_gaddr(0,windows[e_wind].the_dialog,&a_l); 
  299.                                 wind_get(e_wind,WF_WORKXYWH,&x,&y,&w,&h);
  300.                                 if (h!=0)
  301.                                 {
  302.                                     a_l->ob_x=x; 
  303.                                     a_l->ob_y=y;
  304.                                 }
  305.                             }
  306.                                break; 
  307.                         case WM_MOVED:
  308.                             if (mb[4]<0) { mb[4]=0; } 
  309.                             wind_set(e_wind,WF_CURRXYWH,mb[4],mb[5],mb[6],mb[7]); 
  310.                             rsrc_gaddr(0,windows[e_wind].the_dialog,&a_l); 
  311.                             wind_get(e_wind,WF_WORKXYWH,&x,&y,&w,&h); 
  312.                             if (h!=0)
  313.                             { 
  314.                                 a_l->ob_x=x; 
  315.                                 a_l->ob_y=y; 
  316.                             } 
  317.                             break; 
  318.                         case WM_SIZED:
  319.                             widget_handler=widget_callbacks.resize_widget;
  320.                             if (widget_handler)
  321.                             {
  322.                                 (*widget_handler)();
  323.                             }else{
  324.                                 if (mb[4]<0) { mb[4]=0; } 
  325.                                 wind_set(e_wind,WF_CURRXYWH,mb[4],mb[5],mb[6],mb[7]); 
  326.                                 rsrc_gaddr(0,windows[e_wind].the_dialog,&a_l);
  327.                                 wind_get(e_wind,WF_WORKXYWH,&x,&y,&w,&h);
  328.                                 if (h!=0)
  329.                                 {
  330.                                     a_l->ob_x=x; 
  331.                                     a_l->ob_y=y; 
  332.                                 }
  333.                             }
  334.                             break; 
  335.                         case WM_UNICONIFY:
  336.                             wind_get(e_wind,WF_UNICONIFYXYWH,&sx,&sy,&sw,&sh); 
  337.                             wind_set(e_wind,WF_UNICONIFY,0,0,0,0);
  338.                             wind_get(e_wind,WF_CURRXYWH,&sx,&sy,&sw,&sh); 
  339.                             wind_get(e_wind,WF_FULLXYWH,&x,&y,&w,&h); 
  340.                              if ((((sx!=x)||(sy!=y))||(sw!=w))||(sh!=h))
  341.                              {
  342.                                  wind_set(e_wind,WF_CURRXYWH,x,y,w,h);
  343.                              }else{
  344.                                 wind_get(e_wind,WF_PREVXYWH,&x,&y,&w,&h); 
  345.                                  wind_set(e_wind,WF_CURRXYWH,x,y,w,h);
  346.                              }
  347.                              rsrc_gaddr(0,windows[e_wind].the_dialog,&a_l); 
  348.                             wind_get(e_wind,WF_WORKXYWH,&x,&y,&w,&h);
  349.                             if (h!=0)
  350.                             {
  351.                                 a_l->ob_x=x; 
  352.                                 a_l->ob_y=y;
  353.                             }
  354.                                break; 
  355.                     }
  356.                     break;
  357.             }
  358.         }
  359.     }
  360.     return ret_v; 
  361. }
  362.  
  363. short redraw_window(short wind_handle) 
  364. {
  365.      wind_update(BEG_UPDATE); 
  366.     display_dial(wind_handle); 
  367.     wind_update(END_UPDATE);
  368.  
  369.     udx=udy=udw=udh=0 ;
  370.     return 0;
  371. }
  372.  
  373. short custom_redraw_window(short wind_handle) 
  374. {
  375.      wind_update(BEG_UPDATE); 
  376.     custom_display_dial(wind_handle); 
  377.     wind_update(END_UPDATE);
  378.  
  379.     udx=udy=udw=udh=0 ;
  380.     return 0;
  381. }
  382.  
  383. /*
  384.     Set the widget callback for a given dialog
  385. */
  386. void Set_dialog_widget_callback(short dialog, short widget, CallBack c)
  387. {
  388.     if (!(widget&128))
  389.     {
  390.         switch(widget)
  391.         {
  392.             case WIDGET_CLOSE:
  393.                 dialog_details[dialog].wind_widgets.close_widget=c;
  394.                 break;
  395.             case WIDGET_FULL:
  396.                 dialog_details[dialog].wind_widgets.full_widget=c;
  397.                 break;
  398.             case WIDGET_ICONIFY:
  399.                 dialog_details[dialog].wind_widgets.iconify_widget=c;
  400.                 break;
  401.             case WIDGET_RESIZE:
  402.                 dialog_details[dialog].wind_widgets.resize_widget=c;
  403.                 break;
  404.             case WIDGET_H_SLIDE:
  405.                 dialog_details[dialog].wind_widgets.h_slide=c;
  406.                 break;
  407.             case WIDGET_V_SLIDE:
  408.                 dialog_details[dialog].wind_widgets.v_slide=c;
  409.                 break;
  410.         }
  411.     }else{
  412.         dialog_details[dialog].wind_widgets.arrows[widget&~128]=c;
  413.     }
  414. }
  415.